home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / networke / cow / cowl-1.000 / cowl-1 / newwin.c < prev    next >
C/C++ Source or Header  |  1994-03-17  |  34KB  |  919 lines
  1. /*
  2.  * newwin.c
  3.  */
  4. #include "copyright.h"
  5.  
  6. #include <stdio.h>
  7. #include <math.h>
  8. #include <signal.h>
  9. #include <sys/types.h>
  10.  
  11. #ifdef hpux
  12. #include <time.h>
  13. #else                /* hpux */
  14. #include <sys/time.h>
  15. #endif                /* hpux */
  16.  
  17. #include "Wlib.h"
  18. #include "defs.h"
  19. #include "struct.h"
  20. #include "data.h"
  21.  
  22. #ifdef ZZ_BITMAPS
  23. #include "zzbitmaps.h"
  24. #endif
  25.  
  26. #ifdef TNG_FED_BITMAPS
  27. #include "tngbitmaps.h"
  28. #endif
  29.  
  30. #ifdef VARY_HULL
  31. #include "hullbitmaps.h"
  32. #endif
  33.  
  34. #ifndef FONT_BITMAPS
  35. #include "bitmaps/bitmaps.h"
  36. #endif
  37.  
  38. /* define MOO_TEXPBITMAPS to use moo torp explosion bitmaps */
  39. #include "bitmaps/oldbitmaps.h"
  40. #include "packets.h"
  41.  
  42. #ifdef MOOBITMAPS
  43.  
  44. #ifndef FONT_BITMAPS
  45. #include "bitmaps/moobitmaps.h"
  46. #endif
  47.  
  48. #endif
  49.  
  50. #ifdef MOOCURSORS        /* these suck! */
  51. #include "bitmaps/cursors.h"
  52. #endif
  53.  
  54. #include "bitmaps/clockbitmap.h"
  55.  
  56. #ifdef DYNAMIC_BITMAPS
  57. #include "bitmapstuff.h"
  58. #endif
  59.  
  60. #ifdef META
  61. extern int      metaaction ();
  62. #endif
  63.  
  64. #define SIZEOF(a)    (sizeof (a) / sizeof (*(a)))
  65.  
  66. #define BOXSIDE        (WINSIDE / 5)
  67. #define TILESIDE    16
  68. #define MESSAGESIZE    20
  69. #define STATSIZE    (MESSAGESIZE * 2 + BORDER)
  70. #define YOFF        0
  71.  
  72.  
  73. newwin (hostmon, progname)
  74.   char           *hostmon, *progname;
  75. {
  76.   int             i;
  77.  
  78.   W_Initialize (hostmon);
  79.  
  80.   baseWin = W_MakeWindow ("netrek", 0, YOFF, WINSIDE * 2 + 1 * BORDER,
  81.           WINSIDE + 2 * BORDER + 2 * MESSAGESIZE, NULL, BORDER, gColor);
  82.   iconWin = W_MakeWindow ("netrek_icon", 0, 0, icon_width, icon_height, NULL,
  83.               BORDER, gColor);
  84.   W_SetIconWindow (baseWin, iconWin);
  85.   w = W_MakeWindow ("local", -BORDER, -BORDER, WINSIDE, WINSIDE, baseWin,
  86.             BORDER, foreColor);
  87.   mapw = W_MakeWindow ("map", WINSIDE, -BORDER, WINSIDE, WINSIDE, baseWin,
  88.                BORDER, foreColor);
  89.   tstatw = W_MakeWindow ("tstat", -BORDER, WINSIDE, WINSIDE, STATSIZE, baseWin,
  90.              BORDER, foreColor);
  91.   warnw = W_MakeWindow ("warn", WINSIDE, WINSIDE, WINSIDE, MESSAGESIZE,
  92.             baseWin, BORDER, foreColor);
  93.   messagew = W_MakeWindow ("message", WINSIDE, WINSIDE + BORDER + MESSAGESIZE,
  94.                WINSIDE, MESSAGESIZE, baseWin, BORDER, foreColor);
  95.   planetw = W_MakeTextWindow ("planet", 10, 10, 53, MAXPLANETS + 3, w, 2);
  96.   rankw = W_MakeTextWindow ("rank", 50, 300, 65, NUMRANKS + 8, w, 2);
  97.   playerw = W_MakeTextWindow ("player", 0, YOFF + WINSIDE + 2 * BORDER + 2 * MESSAGESIZE,
  98.                   playerlistnum (), MAXPLAYER + 3, NULL, 2);
  99.   helpWin = W_MakeTextWindow ("help", 0, YOFF + WINSIDE + 2 * BORDER + 2 * MESSAGESIZE,
  100.                   160, 21, NULL, BORDER);
  101.  
  102. #ifdef BUTTON_KEYMAP_WINDOW
  103.   but_key_win = W_MakeTextWindow ("buttonkeymap", 0, YOFF + WINSIDE + 2 * 
  104.                   BORDER + 2 * MESSAGESIZE, 90, 10, NULL, BORDER);
  105.  
  106. #endif
  107.  
  108. #ifdef META
  109.     metaWin = W_MakeMenu ("MetaServer List", 0, 0, 69, num_servers + 1,
  110.               NULL, 2);
  111.   W_SetWindowKeyDownHandler (metaWin, metaaction);
  112.   W_SetWindowButtonHandler (metaWin, metaaction);
  113. #endif
  114.  
  115.   messwa = W_MakeScrollingWindow ("review_all", WINSIDE + BORDER,
  116.       YOFF + WINSIDE + 3 * BORDER + 2 * MESSAGESIZE, 80, 10, 0, BORDER);
  117.   messwt = W_MakeScrollingWindow ("review_team", WINSIDE + BORDER,
  118.       YOFF + WINSIDE + 4 * BORDER + 2 * MESSAGESIZE + 10 * W_Textheight + 8,
  119.                   80, 5, 0, BORDER);
  120.   messwi = W_MakeScrollingWindow ("review_your", WINSIDE + BORDER,
  121.      YOFF + WINSIDE + 5 * BORDER + 2 * MESSAGESIZE + 15 * W_Textheight + 16,
  122.                   80, 4, 0, BORDER);
  123.   messwk = W_MakeScrollingWindow ("review_kill", WINSIDE + BORDER,
  124.      YOFF + WINSIDE + 6 * BORDER + 2 * MESSAGESIZE + 19 * W_Textheight + 24,
  125.                   80, 6, 0, BORDER);
  126.   phaserwin = W_MakeScrollingWindow ("review_phaser", WINSIDE + BORDER,
  127.      YOFF + WINSIDE + 3 * BORDER + 2 * MESSAGESIZE + 15 * W_Textheight + 16,
  128.                      80, 4, 0, BORDER);
  129.   reviewWin = W_MakeScrollingWindow ("review", WINSIDE + BORDER,
  130.       YOFF + WINSIDE + 3 * BORDER + 2 * MESSAGESIZE, 80, 20, 0, BORDER);
  131.  
  132.   udpWin = W_MakeMenu ("UDP", WINSIDE + 10, -BORDER + 10, 40, UDP_NUMOPTS,
  133.                NULL, 2);
  134.  
  135. #ifdef NETSTAT
  136.   lMeter = W_MakeWindow ("lagMeter", 0, 600, lMeterWidth (), lMeterHeight (),
  137.              NULL, BORDER, foreColor);
  138. #endif
  139.  
  140. #ifdef PING
  141.   pStats = W_MakeWindow ("pingStats", 0, 600, pStatsWidth (), pStatsHeight (),
  142.              NULL, 1, foreColor);
  143. #endif
  144.  
  145.   for (i = 0; i < 4; i++)
  146.   {
  147.     teamWin[i] = W_MakeWindow (teamshort[1 << i], i * BOXSIDE, 400,
  148.                    BOXSIDE, BOXSIDE, w, 1, foreColor);
  149.   }
  150.   qwin = W_MakeWindow ("quit", 4 * BOXSIDE, 400, BOXSIDE, BOXSIDE, w, 1,
  151.                foreColor);
  152.  
  153. #ifdef ARMY_SLIDER
  154.   statwin = W_MakeWindow ("stats", 422, 13, 160, 110, NULL, 5, foreColor);
  155. #else
  156.   statwin = W_MakeWindow ("stats", 422, 13, 160, 95, NULL, 5, foreColor);
  157. #endif                /* ARMY_SLIDER */
  158.  
  159. #ifdef SCAN
  160.   scanwin = W_MakeWindow ("scanner", 422, 13, 160, 120, baseWin, 5, foreColor);
  161. #endif                /* ATM */
  162.  
  163. #ifdef TCURSORS
  164.  
  165. #ifdef MOOCURSORS
  166.   DefineLocalcursor (w);
  167.   DefineMapcursor (mapw);
  168. #else
  169.   W_DefineTrekCursor (baseWin);
  170.   W_DefineLocalcursor (w);
  171. #endif
  172.  
  173. #ifdef META
  174.   W_DefineArrowCursor (metaWin);
  175. #endif
  176.  
  177.   W_DefineMapcursor (mapw);
  178.   W_DefineTrekCursor (messwa);
  179.   W_DefineTrekCursor (messwt);
  180.   W_DefineTrekCursor (messwi);
  181.   W_DefineTrekCursor (helpWin);
  182.   W_DefineTrekCursor (reviewWin);
  183.   W_DefineTrekCursor (messwk);
  184.   W_DefineTrekCursor (phaserwin);
  185.   W_DefineTrekCursor (playerw);
  186.   W_DefineTrekCursor (rankw);
  187.   W_DefineTrekCursor (statwin);
  188.   W_DefineTrekCursor (iconWin);
  189.   W_DefineTextCursor (messagew);
  190.   W_DefineTrekCursor (tstatw);
  191.   W_DefineWarningCursor (qwin);
  192.  
  193. #ifdef SCAN
  194.   W_DefineTrekCursor (scanwin);
  195. #endif
  196.  
  197.   W_DefineArrowCursor (udpWin);
  198.  
  199. #ifdef NETSTAT
  200.   W_DefineArrowCursor (lMeter);
  201. #endif
  202.  
  203. #ifdef TCURSORS
  204.  
  205. #ifdef MOOTCURSORS
  206.   DefineFedCursor (teamWin[0]);
  207.   DefineRomCursor (teamWin[1]);
  208.   DefineKliCursor (teamWin[2]);
  209.   DefineOriCursor (teamWin[3]);
  210. #else
  211.   for (i = 0; i < 4; i++)
  212.     W_DefineArrowCursor (teamWin[i]);
  213. #endif                /* MOOBITMAPS */
  214.  
  215. #endif                /* TCURSOR */
  216.  
  217. #else
  218.   W_DefineCursor (baseWin, 16, 16, cross_bits, crossmask_bits, 7, 7);
  219.   W_DefineCursor (messwa, 16, 16, cross_bits, crossmask_bits, 7, 7);
  220.   W_DefineCursor (messwt, 16, 16, cross_bits, crossmask_bits, 7, 7);
  221.   W_DefineCursor (messwi, 16, 16, cross_bits, crossmask_bits, 7, 7);
  222.   W_DefineCursor (helpWin, 16, 16, cross_bits, crossmask_bits, 7, 7);
  223.   W_DefineCursor (playerw, 16, 16, cross_bits, crossmask_bits, 7, 7);
  224.   W_DefineCursor (statwin, 16, 16, cross_bits, crossmask_bits, 7, 7);
  225.  
  226. #ifdef SCAN
  227.   W_DefineCursor (scanwin, 16, 16, cross_bits, crossmask_bits, 7, 7);
  228. #endif                /* ATM */
  229.  
  230. #endif
  231.  
  232. #define WARHEIGHT 2
  233. #define WARWIDTH 20
  234. #define WARBORDER 2
  235.  
  236.   war = W_MakeMenu ("war", WINSIDE + 10, -BORDER + 10, WARWIDTH, 6, baseWin,
  237.             WARBORDER);
  238.  
  239. #ifdef TCURSORS
  240.   W_DefineArrowCursor (war);
  241. #endif
  242.  
  243.   getResources (progname);
  244.   savebitmaps ();
  245. #ifdef SHIP_BITMAPS
  246.   read_ship_bitmaps ();
  247. #endif
  248. }
  249.  
  250. mapAll ()
  251. {
  252.   initinput ();
  253.   W_MapWindow (mapw);
  254.   W_MapWindow (tstatw);
  255.   W_MapWindow (warnw);
  256.   W_MapWindow (messagew);
  257.   W_MapWindow (w);
  258.   W_MapWindow (baseWin);
  259.   /*
  260.    * since we aren't mapping windows that have root as parent in x11window.c
  261.    * (since that messes up the TransientFor feature) we have to map them
  262.    * here. (If already mapped, W_MapWindow returns)
  263.    */
  264.  
  265.   if (checkMapped ("planet"))
  266.     W_MapWindow (planetw);
  267.   if (checkMapped ("rank"))
  268.     W_MapWindow (rankw);
  269.   if (checkMapped ("help"))
  270.     W_MapWindow (helpWin);
  271.  
  272. #ifdef META
  273.   if (checkMapped ("MetaServer List"))
  274.     metawindow (metaWin);
  275. #endif
  276.  
  277.   if (checkMapped ("review_all"))
  278.     W_MapWindow (messwa);
  279.   if (checkMapped ("review_team"))
  280.     W_MapWindow (messwt);
  281.   if (checkMapped ("review_your"))
  282.     W_MapWindow (messwi);
  283.   if (checkMapped ("review_kill"))
  284.     W_MapWindow (messwk);
  285.   if (checkMapped ("player"))
  286.     W_MapWindow (playerw);
  287.   if (checkMapped ("review"))
  288.     W_MapWindow (reviewWin);
  289.   if (checkMapped ("UDP"))
  290.     udpwindow ();
  291.  
  292. #ifdef NETSTAT
  293.   if (checkMapped ("lagMeter"))
  294.   {
  295.     netstat = 1;
  296.     W_MapWindow (lMeter);
  297.   }
  298. #endif
  299.  
  300. #ifdef PING
  301.   if (checkMapped ("pingStats"))
  302.     W_MapWindow (pStats);
  303. #endif
  304.  
  305.   if (checkMapped ("review_phaser"))
  306.   {
  307.     W_MapWindow (phaserwin);
  308.     phaserWindow = 1;
  309.   }
  310. }
  311.  
  312. #ifndef FONT_BITMAPS
  313. savebitmaps ()
  314. {
  315.   register int    i;
  316.  
  317. #ifdef DYNAMIC_BITMAPS
  318.   /*
  319.    * store the bitmaps for all the ship types, over all the * teams, over all
  320.    * the views (ugh!)
  321.    */
  322.   for (i = 0; i < VIEWS; i++)
  323.   {
  324.     int             num = 0;
  325.     /* Start FED */
  326.     num = StdBitmapNum (FED, SCOUT);
  327.     ship_bitmaps[num][i] = W_StoreBitmap (fed_scout_width, fed_scout_height,
  328.                       RotateShipViews (fed_scout_bits, i, STD_SHIP_FLGS, num, fed_scout_width), w);
  329.     num = StdBitmapNum (FED, DESTROYER);
  330.     ship_bitmaps[num][i] = W_StoreBitmap (fed_destroyer_width, fed_destroyer_height,
  331.                       RotateShipViews (fed_destroyer_bits, i, STD_SHIP_FLGS, num, fed_destroyer_width), w);
  332.     num = StdBitmapNum (FED, CRUISER);
  333.     ship_bitmaps[num][i] = W_StoreBitmap (fed_cruiser_width, fed_cruiser_height,
  334.                       RotateShipViews (fed_cruiser_bits, i, STD_SHIP_FLGS, num, fed_cruiser_width), w);
  335.     num = StdBitmapNum (FED, BATTLESHIP);
  336.     ship_bitmaps[num][i] = W_StoreBitmap (fed_battleship_width, fed_battleship_height,
  337.                       RotateShipViews (fed_battleship_bits, i, STD_SHIP_FLGS, num, fed_battleship_width), w);
  338.     num = StdBitmapNum (FED, ASSAULT);
  339.     ship_bitmaps[num][i] = W_StoreBitmap (fed_assault_width, fed_assault_height,
  340.                       RotateShipViews (fed_assault_bits, i, STD_SHIP_FLGS, num, fed_assault_width), w);
  341.  
  342. #ifdef GALAXY
  343.     num = StdBitmapNum (FED, SGALAXY);
  344.     ship_bitmaps[num][i] = W_StoreBitmap (fed_galaxy_width, fed_galaxy_height,
  345.                       RotateShipViews (fed_galaxy_bits, i, STD_SHIP_FLGS, num, fed_galaxy_width), w);
  346. #endif                /* GALAXY */
  347.  
  348.     num = StdBitmapNum (FED, STARBASE);
  349.     ship_bitmaps[num][i] = W_StoreBitmap (fed_starbase_width, fed_starbase_height,
  350.                       RotateShipViews (fed_starbase_bits, i, STD_BASE_FLGS, num, fed_starbase_width), w);
  351.  
  352. #ifdef ATT_BITMAPS
  353.     num = StdBitmapNum (FED, ATT);
  354.     ship_bitmaps[num][i] = W_StoreBitmap (fed_att_width, fed_att_height,
  355.     RotateShipViews (fed_att_bits, i, STD_SHIP_FLGS, num, fed_att_width), w);
  356. #else
  357.     num = StdBitmapNum (FED, ATT);
  358.     ship_bitmaps[num][i] = W_StoreBitmap (fed_cruiser_width, fed_cruiser_height,
  359.                       RotateShipViews (fed_cruiser_bits, i, STD_SHIP_FLGS, num, fed_cruiser_width), w);
  360. #endif
  361.  
  362.     /* End FED */
  363.  
  364.     /* Start ROM */
  365.     num = StdBitmapNum (ROM, SCOUT);
  366.     ship_bitmaps[num][i] = W_StoreBitmap (rom_scout_width, rom_scout_height,
  367.                       RotateShipViews (rom_scout_bits, i, STD_SHIP_FLGS, num, rom_scout_width), w);
  368.     num = StdBitmapNum (ROM, DESTROYER);
  369.     ship_bitmaps[num][i] = W_StoreBitmap (rom_destroyer_width, rom_destroyer_height,
  370.                       RotateShipViews (rom_destroyer_bits, i, STD_SHIP_FLGS, num, rom_destroyer_width), w);
  371.     num = StdBitmapNum (ROM, CRUISER);
  372.     ship_bitmaps[num][i] = W_StoreBitmap (rom_cruiser_width, rom_cruiser_height,
  373.                       RotateShipViews (rom_cruiser_bits, i, STD_SHIP_FLGS, num, rom_cruiser_width), w);
  374.     num = StdBitmapNum (ROM, BATTLESHIP);
  375.     ship_bitmaps[num][i] = W_StoreBitmap (rom_battleship_width, rom_battleship_height,
  376.                       RotateShipViews (rom_battleship_bits, i, STD_SHIP_FLGS, num, rom_battleship_width), w);
  377.     num = StdBitmapNum (ROM, ASSAULT);
  378.     ship_bitmaps[num][i] = W_StoreBitmap (rom_assault_width, rom_assault_height,
  379.                       RotateShipViews (rom_assault_bits, i, STD_SHIP_FLGS, num, rom_assault_width), w);
  380.  
  381. #ifdef GALAXY
  382.     num = StdBitmapNum (ROM, SGALAXY);
  383.     ship_bitmaps[num][i] = W_StoreBitmap (rom_galaxy_width, rom_galaxy_height,
  384.                       RotateShipViews (rom_galaxy_bits, i, STD_SHIP_FLGS, num, rom_galaxy_width), w);
  385. #endif                /* GALAXY */
  386.  
  387.     num = StdBitmapNum (ROM, STARBASE);
  388.     ship_bitmaps[num][i] = W_StoreBitmap (rom_starbase_width, rom_starbase_height,
  389.                       RotateShipViews (rom_starbase_bits, i, STD_BASE_FLGS, num, rom_starbase_width), w);
  390.  
  391. #ifdef ATT_BITMAPS
  392.     num = StdBitmapNum (ROM, ATT);
  393.     ship_bitmaps[num][i] = W_StoreBitmap (rom_att_width, rom_att_height,
  394.     RotateShipViews (rom_att_bits, i, STD_SHIP_FLGS, num, rom_att_width), w);
  395. #else
  396.     num = StdBitmapNum (ROM, ATT);
  397.     ship_bitmaps[num][i] = W_StoreBitmap (rom_cruiser_width, rom_cruiser_height,
  398.                       RotateShipViews (rom_cruiser_bits, i, STD_SHIP_FLGS, num, rom_cruiser_width), w);
  399. #endif
  400.  
  401.     /* End ROM */
  402.     /* Start KLI */
  403.     num = StdBitmapNum (KLI, SCOUT);
  404.     ship_bitmaps[num][i] = W_StoreBitmap (kli_scout_width, kli_scout_height,
  405.                       RotateShipViews (kli_scout_bits, i, STD_SHIP_FLGS, num, kli_scout_width), w);
  406.     num = StdBitmapNum (KLI, DESTROYER);
  407.     ship_bitmaps[num][i] = W_StoreBitmap (kli_destroyer_width, kli_destroyer_height,
  408.                       RotateShipViews (kli_destroyer_bits, i, STD_SHIP_FLGS, num, kli_destroyer_width), w);
  409.     num = StdBitmapNum (KLI, CRUISER);
  410.     ship_bitmaps[num][i] = W_StoreBitmap (kli_cruiser_width, kli_cruiser_height,
  411.                       RotateShipViews (kli_cruiser_bits, i, STD_SHIP_FLGS, num, kli_cruiser_width), w);
  412.     num = StdBitmapNum (KLI, BATTLESHIP);
  413.     ship_bitmaps[num][i] = W_StoreBitmap (kli_battleship_width, kli_battleship_height,
  414.                       RotateShipViews (kli_battleship_bits, i, STD_SHIP_FLGS, num, kli_battleship_width), w);
  415.     num = StdBitmapNum (KLI, ASSAULT);
  416.     ship_bitmaps[num][i] = W_StoreBitmap (kli_assault_width, kli_assault_height,
  417.                       RotateShipViews (kli_assault_bits, i, STD_SHIP_FLGS, num, kli_assault_width), w);
  418.  
  419. #ifdef GALAXY
  420.     num = StdBitmapNum (KLI, SGALAXY);
  421.     ship_bitmaps[num][i] = W_StoreBitmap (kli_galaxy_width, kli_galaxy_height,
  422.                       RotateShipViews (kli_galaxy_bits, i, STD_SHIP_FLGS, num, kli_galaxy_width), w);
  423. #endif                /* GALAXY */
  424.  
  425.     num = StdBitmapNum (KLI, STARBASE);
  426.     ship_bitmaps[num][i] = W_StoreBitmap (kli_starbase_width, kli_starbase_height,
  427.                       RotateShipViews (kli_starbase_bits, i, STD_BASE_FLGS, num, kli_starbase_width), w);
  428.  
  429. #ifdef ATT_BITMAPS
  430.     num = StdBitmapNum (KLI, ATT);
  431.     ship_bitmaps[num][i] = W_StoreBitmap (kli_att_width, kli_att_height,
  432.     RotateShipViews (kli_att_bits, i, STD_SHIP_FLGS, num, kli_att_width), w);
  433. #else
  434.     num = StdBitmapNum (KLI, ATT);
  435.     ship_bitmaps[num][i] = W_StoreBitmap (kli_cruiser_width, kli_cruiser_height,
  436.                       RotateShipViews (kli_cruiser_bits, i, STD_SHIP_FLGS, num, kli_cruiser_width), w);
  437. #endif
  438.  
  439.     /* End KLI */
  440.     /* Start ORI */
  441.     num = StdBitmapNum (ORI, SCOUT);
  442.     ship_bitmaps[num][i] = W_StoreBitmap (ori_scout_width, ori_scout_height,
  443.                       RotateShipViews (ori_scout_bits, i, STD_SHIP_FLGS, num, ori_scout_width), w);
  444.     num = StdBitmapNum (ORI, DESTROYER);
  445.     ship_bitmaps[num][i] = W_StoreBitmap (ori_destroyer_width, ori_destroyer_height,
  446.                       RotateShipViews (ori_destroyer_bits, i, STD_SHIP_FLGS, num, ori_destroyer_width), w);
  447.     num = StdBitmapNum (ORI, CRUISER);
  448.     ship_bitmaps[num][i] = W_StoreBitmap (ori_cruiser_width, ori_cruiser_height,
  449.                       RotateShipViews (ori_cruiser_bits, i, STD_SHIP_FLGS, num, ori_cruiser_width), w);
  450.     num = StdBitmapNum (ORI, BATTLESHIP);
  451.     ship_bitmaps[num][i] = W_StoreBitmap (ori_battleship_width, ori_battleship_height,
  452.                       RotateShipViews (ori_battleship_bits, i, STD_SHIP_FLGS, num, ori_battleship_width), w);
  453.     num = StdBitmapNum (ORI, ASSAULT);
  454.     ship_bitmaps[num][i] = W_StoreBitmap (ori_assault_width, ori_assault_height,
  455.                       RotateShipViews (ori_assault_bits, i, STD_SHIP_FLGS, num, ori_assault_width), w);
  456.  
  457. #ifdef GALAXY
  458.     num = StdBitmapNum (ORI, SGALAXY);
  459.     ship_bitmaps[num][i] = W_StoreBitmap (ori_galaxy_width, ori_galaxy_height,
  460.                       RotateShipViews (ori_galaxy_bits, i, STD_SHIP_FLGS, num, ori_galaxy_width), w);
  461. #endif                /* GALAXY */
  462.  
  463.     num = StdBitmapNum (ORI, STARBASE);
  464.     ship_bitmaps[num][i] = W_StoreBitmap (ori_starbase_width, ori_starbase_height,
  465.                       RotateShipViews (ori_starbase_bits, i, STD_BASE_FLGS, num, ori_starbase_width), w);
  466.  
  467. #ifdef ATT_BITMAPS
  468.     num = StdBitmapNum (ORI, ATT);
  469.     ship_bitmaps[num][i] = W_StoreBitmap (ori_att_width, ori_att_height,
  470.     RotateShipViews (ori_att_bits, i, STD_SHIP_FLGS, num, ori_att_width), w);
  471. #else
  472.     num = StdBitmapNum (ORI, ATT);
  473.     ship_bitmaps[num][i] = W_StoreBitmap (ori_cruiser_width, ori_cruiser_height,
  474.                       RotateShipViews (ori_cruiser_bits, i, STD_SHIP_FLGS, num, ori_cruiser_width), w);
  475. #endif
  476.  
  477.     /* End ORI */
  478.     /* Start IND */
  479.     num = StdBitmapNum (IND, SCOUT);
  480.     ship_bitmaps[num][i] = W_StoreBitmap (ind_scout_width, ind_scout_height,
  481.                       RotateShipViews (ind_scout_bits, i, STD_SHIP_FLGS, num, ind_scout_width), w);
  482.     num = StdBitmapNum (IND, DESTROYER);
  483.     ship_bitmaps[num][i] = W_StoreBitmap (ind_destroyer_width, ind_destroyer_height,
  484.                       RotateShipViews (ind_destroyer_bits, i, STD_SHIP_FLGS, num, ind_destroyer_width), w);
  485.     num = StdBitmapNum (IND, CRUISER);
  486.     ship_bitmaps[num][i] = W_StoreBitmap (ind_cruiser_width, ind_cruiser_height,
  487.                       RotateShipViews (ind_cruiser_bits, i, STD_SHIP_FLGS, num, ind_cruiser_width), w);
  488.     num = StdBitmapNum (IND, BATTLESHIP);
  489.     ship_bitmaps[num][i] = W_StoreBitmap (ind_battleship_width, ind_battleship_height,
  490.                       RotateShipViews (ind_battleship_bits, i, STD_SHIP_FLGS, num, ind_battleship_width), w);
  491.     num = StdBitmapNum (IND, ASSAULT);
  492.     ship_bitmaps[num][i] = W_StoreBitmap (ind_assault_width, ind_assault_height,
  493.                       RotateShipViews (ind_assault_bits, i, STD_SHIP_FLGS, num, ind_assault_width), w);
  494.  
  495. #ifdef GALAXY
  496.     num = StdBitmapNum (IND, SGALAXY);
  497.     ship_bitmaps[num][i] = W_StoreBitmap (ind_galaxy_width, ind_galaxy_height,
  498.                       RotateShipViews (ind_galaxy_bits, i, STD_SHIP_FLGS, num, ind_galaxy_width), w);
  499. #endif                /* GALAXY */
  500.  
  501.     num = StdBitmapNum (IND, STARBASE);
  502.     ship_bitmaps[num][i] = W_StoreBitmap (ind_starbase_width, ind_starbase_height,
  503.                       RotateShipViews (ind_starbase_bits, i, STD_BASE_FLGS, num, ind_starbase_width), w);
  504.  
  505. #ifdef ATT_BITMAPS
  506.     num = StdBitmapNum (IND, ATT);
  507.     ship_bitmaps[num][i] = W_StoreBitmap (ind_att_width, ind_att_height,
  508.     RotateShipViews (ind_att_bits, i, STD_SHIP_FLGS, num, ind_att_width), w);
  509. #else
  510.     num = StdBitmapNum (IND, ATT);
  511.     ship_bitmaps[num][i] = W_StoreBitmap (ind_cruiser_width, ind_cruiser_height,
  512.                       RotateShipViews (ind_cruiser_bits, i, STD_SHIP_FLGS, num, ind_cruiser_width), w);
  513. #endif
  514.  
  515.     /* End IND */
  516.   }
  517. #else                /* DYNAMIC_BITMAPS */
  518.   /*
  519.    * store the bitmaps for all the ship types, over all the * teams, over all
  520.    * the views (ugh!)
  521.    */
  522.   for (i = 0; i < VIEWS; i++)
  523.   {
  524.  
  525. #ifdef TNG_FED_BITMAPS
  526.     tng_fed_bitmaps[SCOUT][i] =
  527.       W_StoreBitmap (fed_scout_width, fed_scout_height,
  528.              tng_fed_scout_bits[i], w);
  529.     tng_fed_bitmaps[DESTROYER][i] =
  530.       W_StoreBitmap (fed_destroyer_width, fed_destroyer_height,
  531.              tng_fed_destroyer_bits[i], w);
  532.     tng_fed_bitmaps[CRUISER][i] =
  533.       W_StoreBitmap (fed_cruiser_width, fed_cruiser_height,
  534.              tng_fed_cruiser_bits[i], w);
  535.     tng_fed_bitmaps[BATTLESHIP][i] =
  536.       W_StoreBitmap (fed_battleship_width, fed_battleship_height,
  537.              tng_fed_battleship_bits[i], w);
  538.     tng_fed_bitmaps[ASSAULT][i] =
  539.       W_StoreBitmap (fed_assault_width, fed_assault_height,
  540.              tng_fed_assault_bits[i], w);
  541.     tng_fed_bitmaps[STARBASE][i] =
  542.       W_StoreBitmap (fed_starbase_width, fed_starbase_height,
  543.              fed_starbase_bits[i], w);
  544.  
  545. #ifdef GALAXY
  546.     tng_fed_bitmaps[SGALAXY][i] =
  547.       W_StoreBitmap (fed_galaxy_width, fed_galaxy_width,
  548.              fed_galaxy_bits[i], w);
  549. #endif
  550.  
  551.     tng_fed_bitmaps[ATT][i] =
  552.       W_StoreBitmap (borg_width, borg_height,
  553.              borg_bits, w);
  554. #endif
  555.  
  556. #ifdef ROMVLVS_BITMAPS
  557.     ROMVLVS_bitmap[i] =
  558.       W_StoreBitmap (rom_cruiser_width, rom_cruiser_height,
  559.              ROMVLVS_bits[i], w);
  560. #endif
  561.  
  562.     fed_bitmaps[SCOUT][i] =
  563.       W_StoreBitmap (fed_scout_width, fed_scout_height,
  564.              fed_scout_bits[i], w);
  565.     fed_bitmaps[DESTROYER][i] =
  566.       W_StoreBitmap (fed_destroyer_width, fed_destroyer_height,
  567.              fed_destroyer_bits[i], w);
  568.     fed_bitmaps[CRUISER][i] =
  569.       W_StoreBitmap (fed_cruiser_width, fed_cruiser_height,
  570.              fed_cruiser_bits[i], w);
  571.     fed_bitmaps[BATTLESHIP][i] =
  572.       W_StoreBitmap (fed_battleship_width, fed_battleship_height,
  573.              fed_battleship_bits[i], w);
  574.     fed_bitmaps[ASSAULT][i] =
  575.       W_StoreBitmap (fed_assault_width, fed_assault_height,
  576.              fed_assault_bits[i], w);
  577.     fed_bitmaps[STARBASE][i] =
  578.       W_StoreBitmap (fed_starbase_width, fed_starbase_height,
  579.              fed_starbase_bits[i], w);
  580.  
  581. #ifdef GALAXY
  582.     fed_bitmaps[SGALAXY][i] =
  583.       W_StoreBitmap (fed_galaxy_width, fed_galaxy_width,
  584.              fed_galaxy_bits[i], w);
  585. #endif                /* GALAXY */
  586.  
  587.     fed_bitmaps[ATT][i] =
  588.       W_StoreBitmap (fed_cruiser_width, fed_cruiser_height,
  589.              fed_cruiser_bits[i], w);
  590.  
  591.     kli_bitmaps[SCOUT][i] =
  592.       W_StoreBitmap (kli_scout_width, kli_scout_height,
  593.              kli_scout_bits[i], w);
  594.     kli_bitmaps[DESTROYER][i] =
  595.       W_StoreBitmap (kli_destroyer_width, kli_destroyer_height,
  596.              kli_destroyer_bits[i], w);
  597.     kli_bitmaps[CRUISER][i] =
  598.       W_StoreBitmap (kli_cruiser_width, kli_cruiser_height,
  599.              kli_cruiser_bits[i], w);
  600.     kli_bitmaps[BATTLESHIP][i] =
  601.       W_StoreBitmap (kli_battleship_width, kli_battleship_height,
  602.              kli_battleship_bits[i], w);
  603.     kli_bitmaps[ASSAULT][i] =
  604.       W_StoreBitmap (kli_assault_width, kli_assault_height,
  605.              kli_assault_bits[i], w);
  606.     kli_bitmaps[STARBASE][i] =
  607.       W_StoreBitmap (kli_starbase_width, kli_starbase_height,
  608.              kli_starbase_bits[i], w);
  609.  
  610. #ifdef GALAXY
  611.     kli_bitmaps[SGALAXY][i] =
  612.       W_StoreBitmap (kli_galaxy_width, kli_galaxy_width,
  613.              kli_galaxy_bits[i], w);
  614. #endif                /* GALAXY */
  615.  
  616.     kli_bitmaps[ATT][i] =
  617.       W_StoreBitmap (kli_cruiser_width, kli_cruiser_height,
  618.              kli_cruiser_bits[i], w);
  619.  
  620.     rom_bitmaps[SCOUT][i] =
  621.       W_StoreBitmap (rom_scout_width, rom_scout_height,
  622.              rom_scout_bits[i], w);
  623.     rom_bitmaps[DESTROYER][i] =
  624.       W_StoreBitmap (rom_destroyer_width, rom_destroyer_height,
  625.              rom_destroyer_bits[i], w);
  626.     rom_bitmaps[CRUISER][i] =
  627.       W_StoreBitmap (rom_cruiser_width, rom_cruiser_height,
  628.              rom_cruiser_bits[i], w);
  629.     rom_bitmaps[BATTLESHIP][i] =
  630.       W_StoreBitmap (rom_battleship_width, rom_battleship_height,
  631.              rom_battleship_bits[i], w);
  632.     rom_bitmaps[ASSAULT][i] =
  633.       W_StoreBitmap (rom_assault_width, rom_assault_height,
  634.              rom_assault_bits[i], w);
  635.     rom_bitmaps[STARBASE][i] =
  636.       W_StoreBitmap (rom_starbase_width, rom_starbase_height,
  637.              rom_starbase_bits[i], w);
  638.  
  639. #ifdef GALAXY
  640.     rom_bitmaps[SGALAXY][i] =
  641.       W_StoreBitmap (rom_galaxy_width, rom_galaxy_width,
  642.              rom_galaxy_bits[i], w);
  643. #endif                /* GALAXY */
  644.  
  645.     rom_bitmaps[ATT][i] =
  646.       W_StoreBitmap (rom_cruiser_width, rom_cruiser_height,
  647.              rom_cruiser_bits[i], w);
  648.  
  649.     ori_bitmaps[SCOUT][i] =
  650.       W_StoreBitmap (ori_scout_width, ori_scout_height,
  651.              ori_scout_bits[i], w);
  652.     ori_bitmaps[DESTROYER][i] =
  653.       W_StoreBitmap (ori_destroyer_width, ori_destroyer_height,
  654.              ori_destroyer_bits[i], w);
  655.     ori_bitmaps[CRUISER][i] =
  656.       W_StoreBitmap (ori_cruiser_width, ori_cruiser_height,
  657.              ori_cruiser_bits[i], w);
  658.     ori_bitmaps[BATTLESHIP][i] =
  659.       W_StoreBitmap (ori_battleship_width, ori_battleship_height,
  660.              ori_battleship_bits[i], w);
  661.     ori_bitmaps[ASSAULT][i] =
  662.       W_StoreBitmap (ori_assault_width, ori_assault_height,
  663.              ori_assault_bits[i], w);
  664.     ori_bitmaps[STARBASE][i] =
  665.       W_StoreBitmap (ori_starbase_width, ori_starbase_height,
  666.              ori_starbase_bits[i], w);
  667.  
  668. #ifdef GALAXY
  669.     ori_bitmaps[SGALAXY][i] =
  670.       W_StoreBitmap (ori_galaxy_width, ori_galaxy_width,
  671.              ori_galaxy_bits[i], w);
  672. #endif                /* GALAXY */
  673.  
  674.     ori_bitmaps[ATT][i] =
  675.       W_StoreBitmap (ori_cruiser_width, ori_cruiser_height,
  676.              ori_cruiser_bits[i], w);
  677.  
  678.     ind_bitmaps[SCOUT][i] =
  679.       W_StoreBitmap (ind_scout_width, ind_scout_height,
  680.              ind_scout_bits[i], w);
  681.     ind_bitmaps[DESTROYER][i] =
  682.       W_StoreBitmap (ind_destroyer_width, ind_destroyer_height,
  683.              ind_destroyer_bits[i], w);
  684.     ind_bitmaps[CRUISER][i] =
  685.       W_StoreBitmap (ind_cruiser_width, ind_cruiser_height,
  686.              ind_cruiser_bits[i], w);
  687.     ind_bitmaps[BATTLESHIP][i] =
  688.       W_StoreBitmap (ind_battleship_width, ind_battleship_height,
  689.              ind_battleship_bits[i], w);
  690.     ind_bitmaps[ASSAULT][i] =
  691.       W_StoreBitmap (ind_assault_width, ind_assault_height,
  692.              ind_assault_bits[i], w);
  693.     ind_bitmaps[STARBASE][i] =
  694.       W_StoreBitmap (ind_starbase_width, ind_starbase_height,
  695.              ind_starbase_bits[i], w);
  696.  
  697. #ifdef GALAXY
  698.     ind_bitmaps[SGALAXY][i] =
  699.       W_StoreBitmap (ind_galaxy_width, ind_galaxy_height,
  700.              ind_galaxy_bits[i], w);
  701. #endif                /* GALAXY */
  702.  
  703.  
  704.   }
  705. #endif                /* DYNAMIC_BITMAPS */
  706.  
  707.   /* store the clock bitmap */
  708.   clockpic = W_StoreBitmap (clock_width, clock_height, clock_bits,
  709.                 qwin);
  710.  
  711. #ifdef BEEPLITE
  712.   for (i = 0; i < emph_player_seq_frames; i++)
  713.     {
  714.       emph_player_seq [emph_player_seq_frames - (i + 1)] =
  715.     W_StoreBitmap (emph_player_seq_width, emph_player_seq_height,
  716.                emph_player_seq_bits [i], mapw);
  717.     }
  718.  
  719.   for (i = 0; i < emph_player_seql_frames; i++)
  720.     {
  721.       emph_player_seql [emph_player_seql_frames - (i + 1)] =
  722.     W_StoreBitmap (emph_player_seql_width, emph_player_seql_height,
  723.                emph_player_seql_bits [i], w);
  724.     }
  725.  
  726.   for (i = 0; i < emph_planet_seq_frames; i++)
  727.     {
  728.       emph_planet_seq [emph_planet_seq_frames - (i + 1)] =
  729.     W_StoreBitmap (emph_planet_seq_width, emph_planet_seq_height,
  730.                emph_planet_seq_bits [i], mapw);
  731.     }
  732. #endif
  733.   
  734. /* store the bitmaps for torpedo explosions  */
  735.   for (i = 0; i < 5; i++)
  736.   {
  737.     cloud[i] = W_StoreBitmap (cloud_width, cloud_height, cloud_bits[4 - i], w);
  738.     plasmacloud[i] = W_StoreBitmap (plasmacloud_width,
  739.                 plasmacloud_height, plasmacloud_bits[4 - i], w);
  740.   }
  741.  
  742. #ifdef MAP_NAMES
  743.   show_owner_map_bitmaps [FED] = W_StoreBitmap (mfed_width, mfed_height, 
  744.     mfed_bits, mapw); 
  745.   show_owner_map_bitmaps [ROM] = W_StoreBitmap (mrom_width, mrom_height, 
  746.     mrom_bits, mapw); 
  747.   show_owner_map_bitmaps [KLI] = W_StoreBitmap (mkli_width, mkli_height, 
  748.     mkli_bits, mapw); 
  749.   show_owner_map_bitmaps [ORI] = W_StoreBitmap (mori_width, mori_height, 
  750.     mori_bits, mapw); 
  751. #endif
  752.  
  753.   /* Torpedo bitmaps */
  754.   etorp = W_StoreBitmap (etorp_width, etorp_height, etorp_bits, w);
  755.   mtorp = W_StoreBitmap (mtorp_width, mtorp_height, mtorp_bits, w);
  756.   eplasmatorp =
  757.     W_StoreBitmap (eplasmatorp_width, eplasmatorp_height, eplasmatorp_bits, w);
  758.   mplasmatorp =
  759.     W_StoreBitmap (mplasmatorp_width, mplasmatorp_height, mplasmatorp_bits, w);
  760.  
  761.   /* planet bitmaps */
  762.   bplanets[0] = W_StoreBitmap (planet_width, planet_height, indplanet_bits, w);
  763.   bplanets[1] = W_StoreBitmap (planet_width, planet_height, fedplanet_bits, w);
  764.   bplanets[2] = W_StoreBitmap (planet_width, planet_height, romplanet_bits, w);
  765.   bplanets[3] = W_StoreBitmap (planet_width, planet_height, kliplanet_bits, w);
  766.   bplanets[4] = W_StoreBitmap (planet_width, planet_height, oriplanet_bits, w);
  767.   bplanets[5] = W_StoreBitmap (planet_width, planet_height, planet_bits, w);
  768.   mbplanets[0] = W_StoreBitmap (mplanet_width, mplanet_height, indmplanet_bits, mapw);
  769.   mbplanets[1] = W_StoreBitmap (mplanet_width, mplanet_height, fedmplanet_bits, mapw);
  770.   mbplanets[2] = W_StoreBitmap (mplanet_width, mplanet_height, rommplanet_bits, mapw);
  771.   mbplanets[3] = W_StoreBitmap (mplanet_width, mplanet_height, klimplanet_bits, mapw);
  772.   mbplanets[4] = W_StoreBitmap (mplanet_width, mplanet_height, orimplanet_bits, mapw);
  773.   mbplanets[5] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet_bits, mapw);
  774.   bplanets2[0] = bplanets[0];
  775.   mbplanets2[0] = mbplanets[0];
  776.   bplanets2[1] = W_StoreBitmap (planet_width, planet_height, planet001_bits, w);
  777.   bplanets2[2] = W_StoreBitmap (planet_width, planet_height, planet010_bits, w);
  778.   bplanets2[3] = W_StoreBitmap (planet_width, planet_height, planet011_bits, w);
  779.   bplanets2[4] = W_StoreBitmap (planet_width, planet_height, planet100_bits, w);
  780.   bplanets2[5] = W_StoreBitmap (planet_width, planet_height, planet101_bits, w);
  781.   bplanets2[6] = W_StoreBitmap (planet_width, planet_height, planet110_bits, w);
  782.   bplanets2[7] = W_StoreBitmap (planet_width, planet_height, planet111_bits, w);
  783.   mbplanets2[1] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet001_bits, mapw);
  784.   mbplanets2[2] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet010_bits, mapw);
  785.   mbplanets2[3] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet011_bits, mapw);
  786.   mbplanets2[4] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet100_bits, mapw);
  787.   mbplanets2[5] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet101_bits, mapw);
  788.   mbplanets2[6] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet110_bits, mapw);
  789.   mbplanets2[7] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet111_bits, mapw);
  790.  
  791. #ifdef MOOBITMAPS
  792.   /* isae: My own planet bitmaps */
  793.  
  794.   bplanets[6] = W_StoreBitmap (planet_width, planet_height, myplanet000_bits, w);
  795.  
  796.   bplanets3[0] = W_StoreBitmap (planet_width, planet_height, myplanet000_bits, w);
  797.   bplanets3[1] = W_StoreBitmap (planet_width, planet_height, myplanet001_bits, w);
  798.   bplanets3[2] = W_StoreBitmap (planet_width, planet_height, myplanet010_bits, w);
  799.   bplanets3[3] = W_StoreBitmap (planet_width, planet_height, myplanet011_bits, w);
  800.   bplanets3[4] = W_StoreBitmap (planet_width, planet_height, myplanet100_bits, w);
  801.   bplanets3[5] = W_StoreBitmap (planet_width, planet_height, myplanet101_bits, w);
  802.   bplanets3[6] = W_StoreBitmap (planet_width, planet_height, myplanet110_bits, w);
  803.   bplanets3[7] = W_StoreBitmap (planet_width, planet_height, myplanet111_bits, w);
  804.  
  805.   /* <isae> Added this */
  806.   mbplanets3[0] = W_StoreBitmap (mplanet_width, mplanet_height, myindmplanet_bits, mapw);
  807.   mbplanets3[1] = W_StoreBitmap (mplanet_width, mplanet_height, mymplanet001_bits, mapw);
  808.   mbplanets3[2] = W_StoreBitmap (mplanet_width, mplanet_height, mymplanet010_bits, mapw);
  809.   mbplanets3[3] = W_StoreBitmap (mplanet_width, mplanet_height, mymplanet011_bits, mapw);
  810.   mbplanets3[4] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet100_bits, mapw);
  811.   mbplanets3[5] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet101_bits, mapw);
  812.   mbplanets3[6] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet110_bits, mapw);
  813.   mbplanets3[7] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet111_bits, mapw);
  814. #endif                /* MOOBITMAPS */
  815.  
  816. #ifdef ZZ_BITMAPS
  817.   bplanets4[0] = W_StoreBitmap (planet_width, planet_height, rmyplanet000_bits, w);
  818.   bplanets4[1] = W_StoreBitmap (planet_width, planet_height, rmyplanet001_bits, w);
  819.   bplanets4[2] = W_StoreBitmap (planet_width, planet_height, rmyplanet010_bits, w);
  820.   bplanets4[3] = W_StoreBitmap (planet_width, planet_height, rmyplanet011_bits, w);
  821.   bplanets4[4] = W_StoreBitmap (planet_width, planet_height, rmyplanet100_bits, w);
  822.   bplanets4[5] = W_StoreBitmap (planet_width, planet_height, rmyplanet101_bits, w);
  823.   bplanets4[6] = W_StoreBitmap (planet_width, planet_height, rmyplanet110_bits, w);
  824.   bplanets4[7] = W_StoreBitmap (planet_width, planet_height, rmyplanet111_bits, w);
  825.  
  826.   mbplanets4[0] = W_StoreBitmap (mplanet_width, mplanet_height, rmyindmplanet_bits, mapw);
  827.   mbplanets4[1] = W_StoreBitmap (mplanet_width, mplanet_height, rmymplanet001_bits, mapw);
  828.   mbplanets4[2] = W_StoreBitmap (mplanet_width, mplanet_height, rmymplanet010_bits, mapw);
  829.   mbplanets4[3] = W_StoreBitmap (mplanet_width, mplanet_height, rmymplanet011_bits, mapw);
  830.   mbplanets4[4] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet100_bits, mapw);
  831.   mbplanets4[5] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet101_bits, mapw);
  832.   mbplanets4[6] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet110_bits, mapw);
  833.   mbplanets4[7] = W_StoreBitmap (mplanet_width, mplanet_height, mplanet111_bits, mapw);
  834. #endif
  835.  
  836.   for (i = 0; i < EX_FRAMES; i++)
  837.   {
  838.     expview[i] = W_StoreBitmap (ex_width, ex_height, ex_bits[i], w);
  839.   }
  840.   for (i = 0; i < SBEXPVIEWS; i++)
  841.   {
  842.     sbexpview[i] = W_StoreBitmap (sbexp_width, sbexp_height, sbexp_bits[i], w);
  843.   }
  844.  
  845. #ifndef VSHIELD_BITMAPS
  846.   shield = W_StoreBitmap (shield_width, shield_height, shield_bits, w);
  847. #else
  848.   for (i = 0; i < SHIELD_FRAMES; i++)
  849.     shield[i] = W_StoreBitmap (shield_width, shield_height, shield_bits[i], w);
  850. #endif
  851.  
  852.   cloakicon = W_StoreBitmap (cloak_width, cloak_height, cloak_bits, w);
  853.   icon = W_StoreBitmap (icon_width, icon_height, icon_bits, iconWin);
  854.  
  855. #ifdef VARY_HULL
  856.   for (i = 0; i < HULL_FRAMES; i++)
  857.     hull[i] = W_StoreBitmap (hull_width, hull_height, hull_bits[i], w);
  858. #endif
  859.  
  860. }
  861.  
  862. #endif
  863.  
  864.  
  865. #ifdef MOOCURSORS
  866. /* silly cursor definition stuff from moo */
  867.  
  868. DefineMapcursor (window)
  869.   W_Window        window;
  870. {
  871.   W_DefineCursorFromBitmap (window, mapcursor_bits, mapcursor_width, mapcursor_height,
  872.                 mapmask_bits, mapmask_width, mapmask_height);
  873. }
  874.  
  875. DefineLocalcursor (window)
  876.   W_Window        window;
  877. {
  878.   W_DefineCursorFromBitmap (window, localcursor_bits, localcursor_width, localcursor_height,
  879.              localmask_bits, localmask_width, localmask_height);
  880. }
  881.  
  882. #endif
  883.  
  884.  
  885. #ifdef MOOTCURSORS
  886. DefineFedCursor (window)
  887.   W_Window        window;
  888. {
  889.   W_DefineCursorFromBitmap (window,
  890.        &(fed_cruiser_bits[0][0]), fed_cruiser_width, fed_cruiser_height,
  891.       &(fed_cruiser_bits[0][0]), fed_cruiser_width, fed_cruiser_height);
  892. }
  893.  
  894. DefineRomCursor (window)
  895.   W_Window        window;
  896. {
  897.   W_DefineCursorFromBitmap (window,
  898.          &rom_cruiser_bits[0][0], rom_cruiser_width, rom_cruiser_height,
  899.         &rom_cruiser_bits[0][0], rom_cruiser_width, rom_cruiser_height);
  900. }
  901.  
  902. DefineKliCursor (window)
  903.   W_Window        window;
  904. {
  905.   W_DefineCursorFromBitmap (window,
  906.        &(kli_cruiser_bits[0][0]), kli_cruiser_width, kli_cruiser_height,
  907.       &(kli_cruiser_bits[0][0]), kli_cruiser_width, kli_cruiser_height);
  908. }
  909.  
  910. DefineOriCursor (window)
  911.   W_Window        window;
  912. {
  913.   W_DefineCursorFromBitmap (window,
  914.        &(ori_cruiser_bits[0][0]), ori_cruiser_width, ori_cruiser_height,
  915.       &(ori_cruiser_bits[0][0]), ori_cruiser_width, ori_cruiser_height);
  916. }
  917.  
  918. #endif                /* MOOTCURSORS */
  919.